home *** CD-ROM | disk | FTP | other *** search
/ NetNews Offline 2 / NetNews Offline Volume 2.iso / news / comp / lang / c++-part1 / 7974 < prev    next >
Encoding:
Text File  |  1996-08-05  |  3.7 KB  |  123 lines
  1. Path: news.th-darmstadt.de!news
  2. From: Enno Sandner <enno@intellektik.informatik.th-darmstadt.de>
  3. Newsgroups: comp.lang.c++
  4. Subject: Re: Does this create memory leak?...
  5. Date: Fri, 16 Feb 1996 13:16:39 +0100
  6. Organization: Fachbereich Informatik, TH Darmstadt
  7. Message-ID: <312475A7.2781E494@intellektik.informatik.th-darmstadt.de>
  8. References: <3123DF68.1677@sierra.net>
  9. NNTP-Posting-Host: kitz.intellektik.informatik.th-darmstadt.de
  10. Mime-Version: 1.0
  11. Content-Type: text/plain; charset=us-ascii
  12. Content-Transfer-Encoding: 7bit
  13. X-Mailer: Mozilla 2.0 (X11; I; SunOS 4.1.3 sun4m)
  14.  
  15. T Colwell wrote:
  16. > 
  17. > The code which follows seams like it would create a memory leak.  The CAT class contains member pointers to
  18. > objects on the heap.  When you take an existing object at reassign it via an overridden assignment operator to
  19. > a second object of the same type, what happens to the data at the originally pointed-to address?  Here's what I
  20. > mean:
  21. > 
  22. > *****************************************************
  23. >    #include <iostreams.h>
  24. > 
  25. >    class CAT
  26. >    {
  27. >        public:
  28. >             CAT();    // default constructor
  29. >             // copy constructor and destructor intentionally excluded!
  30. >              int GetAge() const { return *itsAge; }
  31. >              int GetWeight() const { return *itsWeight; }
  32. >              void SetAge(int age) { *itsAge = age; }
  33. >              CAT operator=(const CAT &);
  34. > 
  35. >         private:
  36. >              int *itsAge;
  37. >              int *itsWeight;
  38. >    };
  39. > 
  40. >    CAT::CAT()
  41. >    {
  42. >         itsAge = new int;
  43. >         itsWeight = new int;
  44. >         *itsAge = 5;
  45. >         *itsWeight = 9;
  46. >    }
  47. > 
  48. >   CAT CAT::operator=(const CAT & rhs)
  49. >   {
  50. >      if (this == &rhs)
  51. >         return *this;
  52. >         itsAge = new int;
  53. >         itsWeight = new int;
  54. >         *itsAge = rhs.GetAge();
  55. >         *itsWeight = rhs.GetWeight();
  56. >   }
  57. > 
  58. >    void main()
  59. >    {
  60. >         CAT frisky;
  61. >         frisky.SetAge(6);
  62. >         CAT whiskers;
  63. >         whiskers = frisky; // <--doesn't this leave
  64. >                            // the old members of whiskers
  65. >                            // stranded in the heap?
  66. >    }
  67. > **************************************************
  68. > 
  69. > The assignment operator reinitializes itsAge and itsWeight to point to new heap addresses, what happens to the
  70. > addresses they were pointing to before?  Doesn't this create stranded addresses (leaks)?
  71. > 
  72.  
  73. This code will produce a memory leak whenever you create an
  74. instance of class 'CAT'. Usually one needs a copy-ctor, dtor
  75. and assignment-operator if the ctor isn't trivial.
  76. For instance the following code outlines a possible implementation
  77. >>>>
  78. #include <iostream.h>
  79.  
  80. class CAT {
  81. public:
  82.   CAT() : itsAge(new int(5)), itsWeight(new int(9)) {}
  83.   CAT(const CAT& cat) { Copy(cat); }
  84.   ~CAT() { Destroy(); }
  85.   CAT& operator=(const CAT & cat) {
  86.     if (this!=&cat) { Destroy(); Copy(cat); }
  87.     return *this;
  88.   }
  89.   void SetAge(int age) { *itsAge = age; }
  90.  
  91. private:
  92.   int *itsAge;
  93.   int *itsWeight;
  94.  
  95.   void Destroy() { delete itsAge; delete itsWeight; }
  96.   void Copy(const CAT& cat) {
  97.     itsAge=new int(*cat.itsAge); itsWeight=new int(*cat.itsWeight);
  98.   }
  99. };
  100.  
  101. int main() 
  102. {
  103.   CAT frisky;
  104.   frisky.SetAge(6);
  105.   CAT whiskers;
  106.   whiskers = frisky;
  107.  
  108.   return 0;
  109. }
  110. <<<<
  111. Some notes:
  112.      ctor: The member-initializer list is used to initialize the 
  113.            dynamicly maintained integer values.    
  114. copy-ctor: The copy-construction is delegated to the private function 'Copy'.
  115.      dtor: Again a private function is used to release the allocated
  116.            ressources.
  117.    ass-op: The assignment-operator can now be easily expressed in terms
  118.            of destruction ('Destroy') and copy-construction ('Copy').
  119.  
  120. This guarantees that the class has 'proper copy-semantics'.
  121.  
  122.     Enno
  123.